package mn.idax.exchange.otc.entity;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class CoinExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public CoinExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("Id is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("Id is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Integer value) {
            addCriterion("Id =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("Id <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("Id >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("Id >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
            addCriterion("Id <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("Id <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("Id in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("Id not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("Id between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("Id not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andCodeIsNull() {
            addCriterion("Code is null");
            return (Criteria) this;
        }

        public Criteria andCodeIsNotNull() {
            addCriterion("Code is not null");
            return (Criteria) this;
        }

        public Criteria andCodeEqualTo(String value) {
            addCriterion("Code =", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeNotEqualTo(String value) {
            addCriterion("Code <>", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeGreaterThan(String value) {
            addCriterion("Code >", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeGreaterThanOrEqualTo(String value) {
            addCriterion("Code >=", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeLessThan(String value) {
            addCriterion("Code <", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeLessThanOrEqualTo(String value) {
            addCriterion("Code <=", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeLike(String value) {
            addCriterion("Code like", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeNotLike(String value) {
            addCriterion("Code not like", value, "code");
            return (Criteria) this;
        }

        public Criteria andCodeIn(List<String> values) {
            addCriterion("Code in", values, "code");
            return (Criteria) this;
        }

        public Criteria andCodeNotIn(List<String> values) {
            addCriterion("Code not in", values, "code");
            return (Criteria) this;
        }

        public Criteria andCodeBetween(String value1, String value2) {
            addCriterion("Code between", value1, value2, "code");
            return (Criteria) this;
        }

        public Criteria andCodeNotBetween(String value1, String value2) {
            addCriterion("Code not between", value1, value2, "code");
            return (Criteria) this;
        }

        public Criteria andNameIsNull() {
            addCriterion("Name is null");
            return (Criteria) this;
        }

        public Criteria andNameIsNotNull() {
            addCriterion("Name is not null");
            return (Criteria) this;
        }

        public Criteria andNameEqualTo(String value) {
            addCriterion("Name =", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotEqualTo(String value) {
            addCriterion("Name <>", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameGreaterThan(String value) {
            addCriterion("Name >", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameGreaterThanOrEqualTo(String value) {
            addCriterion("Name >=", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameLessThan(String value) {
            addCriterion("Name <", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameLessThanOrEqualTo(String value) {
            addCriterion("Name <=", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameLike(String value) {
            addCriterion("Name like", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotLike(String value) {
            addCriterion("Name not like", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameIn(List<String> values) {
            addCriterion("Name in", values, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotIn(List<String> values) {
            addCriterion("Name not in", values, "name");
            return (Criteria) this;
        }

        public Criteria andNameBetween(String value1, String value2) {
            addCriterion("Name between", value1, value2, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotBetween(String value1, String value2) {
            addCriterion("Name not between", value1, value2, "name");
            return (Criteria) this;
        }

        public Criteria andCoverImageIsNull() {
            addCriterion("CoverImage is null");
            return (Criteria) this;
        }

        public Criteria andCoverImageIsNotNull() {
            addCriterion("CoverImage is not null");
            return (Criteria) this;
        }

        public Criteria andCoverImageEqualTo(String value) {
            addCriterion("CoverImage =", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageNotEqualTo(String value) {
            addCriterion("CoverImage <>", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageGreaterThan(String value) {
            addCriterion("CoverImage >", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageGreaterThanOrEqualTo(String value) {
            addCriterion("CoverImage >=", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageLessThan(String value) {
            addCriterion("CoverImage <", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageLessThanOrEqualTo(String value) {
            addCriterion("CoverImage <=", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageLike(String value) {
            addCriterion("CoverImage like", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageNotLike(String value) {
            addCriterion("CoverImage not like", value, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageIn(List<String> values) {
            addCriterion("CoverImage in", values, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageNotIn(List<String> values) {
            addCriterion("CoverImage not in", values, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageBetween(String value1, String value2) {
            addCriterion("CoverImage between", value1, value2, "coverImage");
            return (Criteria) this;
        }

        public Criteria andCoverImageNotBetween(String value1, String value2) {
            addCriterion("CoverImage not between", value1, value2, "coverImage");
            return (Criteria) this;
        }

        public Criteria andRpcHostIsNull() {
            addCriterion("RpcHost is null");
            return (Criteria) this;
        }

        public Criteria andRpcHostIsNotNull() {
            addCriterion("RpcHost is not null");
            return (Criteria) this;
        }

        public Criteria andRpcHostEqualTo(String value) {
            addCriterion("RpcHost =", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostNotEqualTo(String value) {
            addCriterion("RpcHost <>", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostGreaterThan(String value) {
            addCriterion("RpcHost >", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostGreaterThanOrEqualTo(String value) {
            addCriterion("RpcHost >=", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostLessThan(String value) {
            addCriterion("RpcHost <", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostLessThanOrEqualTo(String value) {
            addCriterion("RpcHost <=", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostLike(String value) {
            addCriterion("RpcHost like", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostNotLike(String value) {
            addCriterion("RpcHost not like", value, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostIn(List<String> values) {
            addCriterion("RpcHost in", values, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostNotIn(List<String> values) {
            addCriterion("RpcHost not in", values, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostBetween(String value1, String value2) {
            addCriterion("RpcHost between", value1, value2, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcHostNotBetween(String value1, String value2) {
            addCriterion("RpcHost not between", value1, value2, "rpcHost");
            return (Criteria) this;
        }

        public Criteria andRpcPortIsNull() {
            addCriterion("RpcPort is null");
            return (Criteria) this;
        }

        public Criteria andRpcPortIsNotNull() {
            addCriterion("RpcPort is not null");
            return (Criteria) this;
        }

        public Criteria andRpcPortEqualTo(Integer value) {
            addCriterion("RpcPort =", value, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortNotEqualTo(Integer value) {
            addCriterion("RpcPort <>", value, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortGreaterThan(Integer value) {
            addCriterion("RpcPort >", value, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortGreaterThanOrEqualTo(Integer value) {
            addCriterion("RpcPort >=", value, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortLessThan(Integer value) {
            addCriterion("RpcPort <", value, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortLessThanOrEqualTo(Integer value) {
            addCriterion("RpcPort <=", value, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortIn(List<Integer> values) {
            addCriterion("RpcPort in", values, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortNotIn(List<Integer> values) {
            addCriterion("RpcPort not in", values, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortBetween(Integer value1, Integer value2) {
            addCriterion("RpcPort between", value1, value2, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcPortNotBetween(Integer value1, Integer value2) {
            addCriterion("RpcPort not between", value1, value2, "rpcPort");
            return (Criteria) this;
        }

        public Criteria andRpcUserIsNull() {
            addCriterion("RpcUser is null");
            return (Criteria) this;
        }

        public Criteria andRpcUserIsNotNull() {
            addCriterion("RpcUser is not null");
            return (Criteria) this;
        }

        public Criteria andRpcUserEqualTo(String value) {
            addCriterion("RpcUser =", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserNotEqualTo(String value) {
            addCriterion("RpcUser <>", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserGreaterThan(String value) {
            addCriterion("RpcUser >", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserGreaterThanOrEqualTo(String value) {
            addCriterion("RpcUser >=", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserLessThan(String value) {
            addCriterion("RpcUser <", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserLessThanOrEqualTo(String value) {
            addCriterion("RpcUser <=", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserLike(String value) {
            addCriterion("RpcUser like", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserNotLike(String value) {
            addCriterion("RpcUser not like", value, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserIn(List<String> values) {
            addCriterion("RpcUser in", values, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserNotIn(List<String> values) {
            addCriterion("RpcUser not in", values, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserBetween(String value1, String value2) {
            addCriterion("RpcUser between", value1, value2, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcUserNotBetween(String value1, String value2) {
            addCriterion("RpcUser not between", value1, value2, "rpcUser");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordIsNull() {
            addCriterion("RpcPassword is null");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordIsNotNull() {
            addCriterion("RpcPassword is not null");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordEqualTo(String value) {
            addCriterion("RpcPassword =", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordNotEqualTo(String value) {
            addCriterion("RpcPassword <>", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordGreaterThan(String value) {
            addCriterion("RpcPassword >", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordGreaterThanOrEqualTo(String value) {
            addCriterion("RpcPassword >=", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordLessThan(String value) {
            addCriterion("RpcPassword <", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordLessThanOrEqualTo(String value) {
            addCriterion("RpcPassword <=", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordLike(String value) {
            addCriterion("RpcPassword like", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordNotLike(String value) {
            addCriterion("RpcPassword not like", value, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordIn(List<String> values) {
            addCriterion("RpcPassword in", values, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordNotIn(List<String> values) {
            addCriterion("RpcPassword not in", values, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordBetween(String value1, String value2) {
            addCriterion("RpcPassword between", value1, value2, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcPasswordNotBetween(String value1, String value2) {
            addCriterion("RpcPassword not between", value1, value2, "rpcPassword");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutIsNull() {
            addCriterion("RpcTimeout is null");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutIsNotNull() {
            addCriterion("RpcTimeout is not null");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutEqualTo(Short value) {
            addCriterion("RpcTimeout =", value, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutNotEqualTo(Short value) {
            addCriterion("RpcTimeout <>", value, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutGreaterThan(Short value) {
            addCriterion("RpcTimeout >", value, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutGreaterThanOrEqualTo(Short value) {
            addCriterion("RpcTimeout >=", value, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutLessThan(Short value) {
            addCriterion("RpcTimeout <", value, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutLessThanOrEqualTo(Short value) {
            addCriterion("RpcTimeout <=", value, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutIn(List<Short> values) {
            addCriterion("RpcTimeout in", values, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutNotIn(List<Short> values) {
            addCriterion("RpcTimeout not in", values, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutBetween(Short value1, Short value2) {
            addCriterion("RpcTimeout between", value1, value2, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andRpcTimeoutNotBetween(Short value1, Short value2) {
            addCriterion("RpcTimeout not between", value1, value2, "rpcTimeout");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordIsNull() {
            addCriterion("EncryptedWalletPassword is null");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordIsNotNull() {
            addCriterion("EncryptedWalletPassword is not null");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordEqualTo(String value) {
            addCriterion("EncryptedWalletPassword =", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordNotEqualTo(String value) {
            addCriterion("EncryptedWalletPassword <>", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordGreaterThan(String value) {
            addCriterion("EncryptedWalletPassword >", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordGreaterThanOrEqualTo(String value) {
            addCriterion("EncryptedWalletPassword >=", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordLessThan(String value) {
            addCriterion("EncryptedWalletPassword <", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordLessThanOrEqualTo(String value) {
            addCriterion("EncryptedWalletPassword <=", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordLike(String value) {
            addCriterion("EncryptedWalletPassword like", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordNotLike(String value) {
            addCriterion("EncryptedWalletPassword not like", value, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordIn(List<String> values) {
            addCriterion("EncryptedWalletPassword in", values, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordNotIn(List<String> values) {
            addCriterion("EncryptedWalletPassword not in", values, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordBetween(String value1, String value2) {
            addCriterion("EncryptedWalletPassword between", value1, value2, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedWalletPasswordNotBetween(String value1, String value2) {
            addCriterion("EncryptedWalletPassword not between", value1, value2, "encryptedWalletPassword");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledIsNull() {
            addCriterion("IsDepositEnabled is null");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledIsNotNull() {
            addCriterion("IsDepositEnabled is not null");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledEqualTo(Boolean value) {
            addCriterion("IsDepositEnabled =", value, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledNotEqualTo(Boolean value) {
            addCriterion("IsDepositEnabled <>", value, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledGreaterThan(Boolean value) {
            addCriterion("IsDepositEnabled >", value, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledGreaterThanOrEqualTo(Boolean value) {
            addCriterion("IsDepositEnabled >=", value, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledLessThan(Boolean value) {
            addCriterion("IsDepositEnabled <", value, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledLessThanOrEqualTo(Boolean value) {
            addCriterion("IsDepositEnabled <=", value, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledIn(List<Boolean> values) {
            addCriterion("IsDepositEnabled in", values, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledNotIn(List<Boolean> values) {
            addCriterion("IsDepositEnabled not in", values, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledBetween(Boolean value1, Boolean value2) {
            addCriterion("IsDepositEnabled between", value1, value2, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsDepositEnabledNotBetween(Boolean value1, Boolean value2) {
            addCriterion("IsDepositEnabled not between", value1, value2, "isDepositEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledIsNull() {
            addCriterion("IsWithdrawEnabled is null");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledIsNotNull() {
            addCriterion("IsWithdrawEnabled is not null");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledEqualTo(Boolean value) {
            addCriterion("IsWithdrawEnabled =", value, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledNotEqualTo(Boolean value) {
            addCriterion("IsWithdrawEnabled <>", value, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledGreaterThan(Boolean value) {
            addCriterion("IsWithdrawEnabled >", value, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledGreaterThanOrEqualTo(Boolean value) {
            addCriterion("IsWithdrawEnabled >=", value, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledLessThan(Boolean value) {
            addCriterion("IsWithdrawEnabled <", value, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledLessThanOrEqualTo(Boolean value) {
            addCriterion("IsWithdrawEnabled <=", value, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledIn(List<Boolean> values) {
            addCriterion("IsWithdrawEnabled in", values, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledNotIn(List<Boolean> values) {
            addCriterion("IsWithdrawEnabled not in", values, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledBetween(Boolean value1, Boolean value2) {
            addCriterion("IsWithdrawEnabled between", value1, value2, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andIsWithdrawEnabledNotBetween(Boolean value1, Boolean value2) {
            addCriterion("IsWithdrawEnabled not between", value1, value2, "isWithdrawEnabled");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeIsNull() {
            addCriterion("WithdrawFee is null");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeIsNotNull() {
            addCriterion("WithdrawFee is not null");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeEqualTo(BigDecimal value) {
            addCriterion("WithdrawFee =", value, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeNotEqualTo(BigDecimal value) {
            addCriterion("WithdrawFee <>", value, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeGreaterThan(BigDecimal value) {
            addCriterion("WithdrawFee >", value, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("WithdrawFee >=", value, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeLessThan(BigDecimal value) {
            addCriterion("WithdrawFee <", value, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeLessThanOrEqualTo(BigDecimal value) {
            addCriterion("WithdrawFee <=", value, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeIn(List<BigDecimal> values) {
            addCriterion("WithdrawFee in", values, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeNotIn(List<BigDecimal> values) {
            addCriterion("WithdrawFee not in", values, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("WithdrawFee between", value1, value2, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andWithdrawFeeNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("WithdrawFee not between", value1, value2, "withdrawFee");
            return (Criteria) this;
        }

        public Criteria andContractAddressIsNull() {
            addCriterion("ContractAddress is null");
            return (Criteria) this;
        }

        public Criteria andContractAddressIsNotNull() {
            addCriterion("ContractAddress is not null");
            return (Criteria) this;
        }

        public Criteria andContractAddressEqualTo(String value) {
            addCriterion("ContractAddress =", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressNotEqualTo(String value) {
            addCriterion("ContractAddress <>", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressGreaterThan(String value) {
            addCriterion("ContractAddress >", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressGreaterThanOrEqualTo(String value) {
            addCriterion("ContractAddress >=", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressLessThan(String value) {
            addCriterion("ContractAddress <", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressLessThanOrEqualTo(String value) {
            addCriterion("ContractAddress <=", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressLike(String value) {
            addCriterion("ContractAddress like", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressNotLike(String value) {
            addCriterion("ContractAddress not like", value, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressIn(List<String> values) {
            addCriterion("ContractAddress in", values, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressNotIn(List<String> values) {
            addCriterion("ContractAddress not in", values, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressBetween(String value1, String value2) {
            addCriterion("ContractAddress between", value1, value2, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andContractAddressNotBetween(String value1, String value2) {
            addCriterion("ContractAddress not between", value1, value2, "contractAddress");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountIsNull() {
            addCriterion("LowWithdrawAmount is null");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountIsNotNull() {
            addCriterion("LowWithdrawAmount is not null");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawAmount =", value, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountNotEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawAmount <>", value, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountGreaterThan(BigDecimal value) {
            addCriterion("LowWithdrawAmount >", value, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawAmount >=", value, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountLessThan(BigDecimal value) {
            addCriterion("LowWithdrawAmount <", value, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountLessThanOrEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawAmount <=", value, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountIn(List<BigDecimal> values) {
            addCriterion("LowWithdrawAmount in", values, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountNotIn(List<BigDecimal> values) {
            addCriterion("LowWithdrawAmount not in", values, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("LowWithdrawAmount between", value1, value2, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawAmountNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("LowWithdrawAmount not between", value1, value2, "lowWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountIsNull() {
            addCriterion("MaxWithdrawAmount is null");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountIsNotNull() {
            addCriterion("MaxWithdrawAmount is not null");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountEqualTo(BigDecimal value) {
            addCriterion("MaxWithdrawAmount =", value, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountNotEqualTo(BigDecimal value) {
            addCriterion("MaxWithdrawAmount <>", value, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountGreaterThan(BigDecimal value) {
            addCriterion("MaxWithdrawAmount >", value, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("MaxWithdrawAmount >=", value, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountLessThan(BigDecimal value) {
            addCriterion("MaxWithdrawAmount <", value, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountLessThanOrEqualTo(BigDecimal value) {
            addCriterion("MaxWithdrawAmount <=", value, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountIn(List<BigDecimal> values) {
            addCriterion("MaxWithdrawAmount in", values, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountNotIn(List<BigDecimal> values) {
            addCriterion("MaxWithdrawAmount not in", values, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MaxWithdrawAmount between", value1, value2, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andMaxWithdrawAmountNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MaxWithdrawAmount not between", value1, value2, "maxWithdrawAmount");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeIsNull() {
            addCriterion("LowWithdrawFee is null");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeIsNotNull() {
            addCriterion("LowWithdrawFee is not null");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawFee =", value, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeNotEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawFee <>", value, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeGreaterThan(BigDecimal value) {
            addCriterion("LowWithdrawFee >", value, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawFee >=", value, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeLessThan(BigDecimal value) {
            addCriterion("LowWithdrawFee <", value, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeLessThanOrEqualTo(BigDecimal value) {
            addCriterion("LowWithdrawFee <=", value, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeIn(List<BigDecimal> values) {
            addCriterion("LowWithdrawFee in", values, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeNotIn(List<BigDecimal> values) {
            addCriterion("LowWithdrawFee not in", values, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("LowWithdrawFee between", value1, value2, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andLowWithdrawFeeNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("LowWithdrawFee not between", value1, value2, "lowWithdrawFee");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsIsNull() {
            addCriterion("DepositMinConfirms is null");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsIsNotNull() {
            addCriterion("DepositMinConfirms is not null");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsEqualTo(Integer value) {
            addCriterion("DepositMinConfirms =", value, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsNotEqualTo(Integer value) {
            addCriterion("DepositMinConfirms <>", value, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsGreaterThan(Integer value) {
            addCriterion("DepositMinConfirms >", value, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsGreaterThanOrEqualTo(Integer value) {
            addCriterion("DepositMinConfirms >=", value, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsLessThan(Integer value) {
            addCriterion("DepositMinConfirms <", value, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsLessThanOrEqualTo(Integer value) {
            addCriterion("DepositMinConfirms <=", value, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsIn(List<Integer> values) {
            addCriterion("DepositMinConfirms in", values, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsNotIn(List<Integer> values) {
            addCriterion("DepositMinConfirms not in", values, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsBetween(Integer value1, Integer value2) {
            addCriterion("DepositMinConfirms between", value1, value2, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andDepositMinConfirmsNotBetween(Integer value1, Integer value2) {
            addCriterion("DepositMinConfirms not between", value1, value2, "depositMinConfirms");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatIsNull() {
            addCriterion("TxUrlFormat is null");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatIsNotNull() {
            addCriterion("TxUrlFormat is not null");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatEqualTo(String value) {
            addCriterion("TxUrlFormat =", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatNotEqualTo(String value) {
            addCriterion("TxUrlFormat <>", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatGreaterThan(String value) {
            addCriterion("TxUrlFormat >", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatGreaterThanOrEqualTo(String value) {
            addCriterion("TxUrlFormat >=", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatLessThan(String value) {
            addCriterion("TxUrlFormat <", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatLessThanOrEqualTo(String value) {
            addCriterion("TxUrlFormat <=", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatLike(String value) {
            addCriterion("TxUrlFormat like", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatNotLike(String value) {
            addCriterion("TxUrlFormat not like", value, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatIn(List<String> values) {
            addCriterion("TxUrlFormat in", values, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatNotIn(List<String> values) {
            addCriterion("TxUrlFormat not in", values, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatBetween(String value1, String value2) {
            addCriterion("TxUrlFormat between", value1, value2, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andTxUrlFormatNotBetween(String value1, String value2) {
            addCriterion("TxUrlFormat not between", value1, value2, "txUrlFormat");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberIsNull() {
            addCriterion("LatestBlockNumber is null");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberIsNotNull() {
            addCriterion("LatestBlockNumber is not null");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberEqualTo(Integer value) {
            addCriterion("LatestBlockNumber =", value, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberNotEqualTo(Integer value) {
            addCriterion("LatestBlockNumber <>", value, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberGreaterThan(Integer value) {
            addCriterion("LatestBlockNumber >", value, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberGreaterThanOrEqualTo(Integer value) {
            addCriterion("LatestBlockNumber >=", value, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberLessThan(Integer value) {
            addCriterion("LatestBlockNumber <", value, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberLessThanOrEqualTo(Integer value) {
            addCriterion("LatestBlockNumber <=", value, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberIn(List<Integer> values) {
            addCriterion("LatestBlockNumber in", values, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberNotIn(List<Integer> values) {
            addCriterion("LatestBlockNumber not in", values, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberBetween(Integer value1, Integer value2) {
            addCriterion("LatestBlockNumber between", value1, value2, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andLatestBlockNumberNotBetween(Integer value1, Integer value2) {
            addCriterion("LatestBlockNumber not between", value1, value2, "latestBlockNumber");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIsNull() {
            addCriterion("CreateTime is null");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIsNotNull() {
            addCriterion("CreateTime is not null");
            return (Criteria) this;
        }

        public Criteria andCreateTimeEqualTo(Date value) {
            addCriterion("CreateTime =", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotEqualTo(Date value) {
            addCriterion("CreateTime <>", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeGreaterThan(Date value) {
            addCriterion("CreateTime >", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("CreateTime >=", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeLessThan(Date value) {
            addCriterion("CreateTime <", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
            addCriterion("CreateTime <=", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIn(List<Date> values) {
            addCriterion("CreateTime in", values, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotIn(List<Date> values) {
            addCriterion("CreateTime not in", values, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeBetween(Date value1, Date value2) {
            addCriterion("CreateTime between", value1, value2, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
            addCriterion("CreateTime not between", value1, value2, "createTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeIsNull() {
            addCriterion("UpdateTime is null");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeIsNotNull() {
            addCriterion("UpdateTime is not null");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeEqualTo(Date value) {
            addCriterion("UpdateTime =", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeNotEqualTo(Date value) {
            addCriterion("UpdateTime <>", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeGreaterThan(Date value) {
            addCriterion("UpdateTime >", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("UpdateTime >=", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeLessThan(Date value) {
            addCriterion("UpdateTime <", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeLessThanOrEqualTo(Date value) {
            addCriterion("UpdateTime <=", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeIn(List<Date> values) {
            addCriterion("UpdateTime in", values, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeNotIn(List<Date> values) {
            addCriterion("UpdateTime not in", values, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeBetween(Date value1, Date value2) {
            addCriterion("UpdateTime between", value1, value2, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeNotBetween(Date value1, Date value2) {
            addCriterion("UpdateTime not between", value1, value2, "updateTime");
            return (Criteria) this;
        }

        public Criteria andIsVisibleIsNull() {
            addCriterion("IsVisible is null");
            return (Criteria) this;
        }

        public Criteria andIsVisibleIsNotNull() {
            addCriterion("IsVisible is not null");
            return (Criteria) this;
        }

        public Criteria andIsVisibleEqualTo(Boolean value) {
            addCriterion("IsVisible =", value, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleNotEqualTo(Boolean value) {
            addCriterion("IsVisible <>", value, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleGreaterThan(Boolean value) {
            addCriterion("IsVisible >", value, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleGreaterThanOrEqualTo(Boolean value) {
            addCriterion("IsVisible >=", value, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleLessThan(Boolean value) {
            addCriterion("IsVisible <", value, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleLessThanOrEqualTo(Boolean value) {
            addCriterion("IsVisible <=", value, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleIn(List<Boolean> values) {
            addCriterion("IsVisible in", values, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleNotIn(List<Boolean> values) {
            addCriterion("IsVisible not in", values, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleBetween(Boolean value1, Boolean value2) {
            addCriterion("IsVisible between", value1, value2, "isVisible");
            return (Criteria) this;
        }

        public Criteria andIsVisibleNotBetween(Boolean value1, Boolean value2) {
            addCriterion("IsVisible not between", value1, value2, "isVisible");
            return (Criteria) this;
        }

        public Criteria andWalletProviderIsNull() {
            addCriterion("WalletProvider is null");
            return (Criteria) this;
        }

        public Criteria andWalletProviderIsNotNull() {
            addCriterion("WalletProvider is not null");
            return (Criteria) this;
        }

        public Criteria andWalletProviderEqualTo(String value) {
            addCriterion("WalletProvider =", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderNotEqualTo(String value) {
            addCriterion("WalletProvider <>", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderGreaterThan(String value) {
            addCriterion("WalletProvider >", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderGreaterThanOrEqualTo(String value) {
            addCriterion("WalletProvider >=", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderLessThan(String value) {
            addCriterion("WalletProvider <", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderLessThanOrEqualTo(String value) {
            addCriterion("WalletProvider <=", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderLike(String value) {
            addCriterion("WalletProvider like", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderNotLike(String value) {
            addCriterion("WalletProvider not like", value, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderIn(List<String> values) {
            addCriterion("WalletProvider in", values, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderNotIn(List<String> values) {
            addCriterion("WalletProvider not in", values, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderBetween(String value1, String value2) {
            addCriterion("WalletProvider between", value1, value2, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andWalletProviderNotBetween(String value1, String value2) {
            addCriterion("WalletProvider not between", value1, value2, "walletProvider");
            return (Criteria) this;
        }

        public Criteria andFixedFeeIsNull() {
            addCriterion("FixedFee is null");
            return (Criteria) this;
        }

        public Criteria andFixedFeeIsNotNull() {
            addCriterion("FixedFee is not null");
            return (Criteria) this;
        }

        public Criteria andFixedFeeEqualTo(BigDecimal value) {
            addCriterion("FixedFee =", value, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeNotEqualTo(BigDecimal value) {
            addCriterion("FixedFee <>", value, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeGreaterThan(BigDecimal value) {
            addCriterion("FixedFee >", value, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("FixedFee >=", value, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeLessThan(BigDecimal value) {
            addCriterion("FixedFee <", value, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeLessThanOrEqualTo(BigDecimal value) {
            addCriterion("FixedFee <=", value, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeIn(List<BigDecimal> values) {
            addCriterion("FixedFee in", values, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeNotIn(List<BigDecimal> values) {
            addCriterion("FixedFee not in", values, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FixedFee between", value1, value2, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andFixedFeeNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("FixedFee not between", value1, value2, "fixedFee");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceIsNull() {
            addCriterion("Erc20DecimalPlace is null");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceIsNotNull() {
            addCriterion("Erc20DecimalPlace is not null");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceEqualTo(Integer value) {
            addCriterion("Erc20DecimalPlace =", value, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceNotEqualTo(Integer value) {
            addCriterion("Erc20DecimalPlace <>", value, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceGreaterThan(Integer value) {
            addCriterion("Erc20DecimalPlace >", value, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceGreaterThanOrEqualTo(Integer value) {
            addCriterion("Erc20DecimalPlace >=", value, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceLessThan(Integer value) {
            addCriterion("Erc20DecimalPlace <", value, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceLessThanOrEqualTo(Integer value) {
            addCriterion("Erc20DecimalPlace <=", value, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceIn(List<Integer> values) {
            addCriterion("Erc20DecimalPlace in", values, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceNotIn(List<Integer> values) {
            addCriterion("Erc20DecimalPlace not in", values, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceBetween(Integer value1, Integer value2) {
            addCriterion("Erc20DecimalPlace between", value1, value2, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andErc20DecimalPlaceNotBetween(Integer value1, Integer value2) {
            addCriterion("Erc20DecimalPlace not between", value1, value2, "erc20DecimalPlace");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxIsNull() {
            addCriterion("WithdrawMax is null");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxIsNotNull() {
            addCriterion("WithdrawMax is not null");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxEqualTo(BigDecimal value) {
            addCriterion("WithdrawMax =", value, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxNotEqualTo(BigDecimal value) {
            addCriterion("WithdrawMax <>", value, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxGreaterThan(BigDecimal value) {
            addCriterion("WithdrawMax >", value, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("WithdrawMax >=", value, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxLessThan(BigDecimal value) {
            addCriterion("WithdrawMax <", value, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxLessThanOrEqualTo(BigDecimal value) {
            addCriterion("WithdrawMax <=", value, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxIn(List<BigDecimal> values) {
            addCriterion("WithdrawMax in", values, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxNotIn(List<BigDecimal> values) {
            addCriterion("WithdrawMax not in", values, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("WithdrawMax between", value1, value2, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andWithdrawMaxNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("WithdrawMax not between", value1, value2, "withdrawMax");
            return (Criteria) this;
        }

        public Criteria andTokenTypeIsNull() {
            addCriterion("TokenType is null");
            return (Criteria) this;
        }

        public Criteria andTokenTypeIsNotNull() {
            addCriterion("TokenType is not null");
            return (Criteria) this;
        }

        public Criteria andTokenTypeEqualTo(Integer value) {
            addCriterion("TokenType =", value, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeNotEqualTo(Integer value) {
            addCriterion("TokenType <>", value, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeGreaterThan(Integer value) {
            addCriterion("TokenType >", value, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeGreaterThanOrEqualTo(Integer value) {
            addCriterion("TokenType >=", value, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeLessThan(Integer value) {
            addCriterion("TokenType <", value, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeLessThanOrEqualTo(Integer value) {
            addCriterion("TokenType <=", value, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeIn(List<Integer> values) {
            addCriterion("TokenType in", values, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeNotIn(List<Integer> values) {
            addCriterion("TokenType not in", values, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeBetween(Integer value1, Integer value2) {
            addCriterion("TokenType between", value1, value2, "tokenType");
            return (Criteria) this;
        }

        public Criteria andTokenTypeNotBetween(Integer value1, Integer value2) {
            addCriterion("TokenType not between", value1, value2, "tokenType");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberIsNull() {
            addCriterion("LatestAccountHistoryNumber is null");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberIsNotNull() {
            addCriterion("LatestAccountHistoryNumber is not null");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberEqualTo(Integer value) {
            addCriterion("LatestAccountHistoryNumber =", value, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberNotEqualTo(Integer value) {
            addCriterion("LatestAccountHistoryNumber <>", value, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberGreaterThan(Integer value) {
            addCriterion("LatestAccountHistoryNumber >", value, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberGreaterThanOrEqualTo(Integer value) {
            addCriterion("LatestAccountHistoryNumber >=", value, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberLessThan(Integer value) {
            addCriterion("LatestAccountHistoryNumber <", value, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberLessThanOrEqualTo(Integer value) {
            addCriterion("LatestAccountHistoryNumber <=", value, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberIn(List<Integer> values) {
            addCriterion("LatestAccountHistoryNumber in", values, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberNotIn(List<Integer> values) {
            addCriterion("LatestAccountHistoryNumber not in", values, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberBetween(Integer value1, Integer value2) {
            addCriterion("LatestAccountHistoryNumber between", value1, value2, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andLatestAccountHistoryNumberNotBetween(Integer value1, Integer value2) {
            addCriterion("LatestAccountHistoryNumber not between", value1, value2, "latestAccountHistoryNumber");
            return (Criteria) this;
        }

        public Criteria andRpcPort2IsNull() {
            addCriterion("RpcPort2 is null");
            return (Criteria) this;
        }

        public Criteria andRpcPort2IsNotNull() {
            addCriterion("RpcPort2 is not null");
            return (Criteria) this;
        }

        public Criteria andRpcPort2EqualTo(Integer value) {
            addCriterion("RpcPort2 =", value, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2NotEqualTo(Integer value) {
            addCriterion("RpcPort2 <>", value, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2GreaterThan(Integer value) {
            addCriterion("RpcPort2 >", value, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2GreaterThanOrEqualTo(Integer value) {
            addCriterion("RpcPort2 >=", value, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2LessThan(Integer value) {
            addCriterion("RpcPort2 <", value, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2LessThanOrEqualTo(Integer value) {
            addCriterion("RpcPort2 <=", value, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2In(List<Integer> values) {
            addCriterion("RpcPort2 in", values, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2NotIn(List<Integer> values) {
            addCriterion("RpcPort2 not in", values, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2Between(Integer value1, Integer value2) {
            addCriterion("RpcPort2 between", value1, value2, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andRpcPort2NotBetween(Integer value1, Integer value2) {
            addCriterion("RpcPort2 not between", value1, value2, "rpcPort2");
            return (Criteria) this;
        }

        public Criteria andWalletAccountIsNull() {
            addCriterion("WalletAccount is null");
            return (Criteria) this;
        }

        public Criteria andWalletAccountIsNotNull() {
            addCriterion("WalletAccount is not null");
            return (Criteria) this;
        }

        public Criteria andWalletAccountEqualTo(String value) {
            addCriterion("WalletAccount =", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountNotEqualTo(String value) {
            addCriterion("WalletAccount <>", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountGreaterThan(String value) {
            addCriterion("WalletAccount >", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountGreaterThanOrEqualTo(String value) {
            addCriterion("WalletAccount >=", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountLessThan(String value) {
            addCriterion("WalletAccount <", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountLessThanOrEqualTo(String value) {
            addCriterion("WalletAccount <=", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountLike(String value) {
            addCriterion("WalletAccount like", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountNotLike(String value) {
            addCriterion("WalletAccount not like", value, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountIn(List<String> values) {
            addCriterion("WalletAccount in", values, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountNotIn(List<String> values) {
            addCriterion("WalletAccount not in", values, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountBetween(String value1, String value2) {
            addCriterion("WalletAccount between", value1, value2, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccountNotBetween(String value1, String value2) {
            addCriterion("WalletAccount not between", value1, value2, "walletAccount");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2IsNull() {
            addCriterion("WalletAccount2 is null");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2IsNotNull() {
            addCriterion("WalletAccount2 is not null");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2EqualTo(String value) {
            addCriterion("WalletAccount2 =", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2NotEqualTo(String value) {
            addCriterion("WalletAccount2 <>", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2GreaterThan(String value) {
            addCriterion("WalletAccount2 >", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2GreaterThanOrEqualTo(String value) {
            addCriterion("WalletAccount2 >=", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2LessThan(String value) {
            addCriterion("WalletAccount2 <", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2LessThanOrEqualTo(String value) {
            addCriterion("WalletAccount2 <=", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2Like(String value) {
            addCriterion("WalletAccount2 like", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2NotLike(String value) {
            addCriterion("WalletAccount2 not like", value, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2In(List<String> values) {
            addCriterion("WalletAccount2 in", values, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2NotIn(List<String> values) {
            addCriterion("WalletAccount2 not in", values, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2Between(String value1, String value2) {
            addCriterion("WalletAccount2 between", value1, value2, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andWalletAccount2NotBetween(String value1, String value2) {
            addCriterion("WalletAccount2 not between", value1, value2, "walletAccount2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordIsNull() {
            addCriterion("EncryptedClientPassword is null");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordIsNotNull() {
            addCriterion("EncryptedClientPassword is not null");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordEqualTo(String value) {
            addCriterion("EncryptedClientPassword =", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordNotEqualTo(String value) {
            addCriterion("EncryptedClientPassword <>", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordGreaterThan(String value) {
            addCriterion("EncryptedClientPassword >", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordGreaterThanOrEqualTo(String value) {
            addCriterion("EncryptedClientPassword >=", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordLessThan(String value) {
            addCriterion("EncryptedClientPassword <", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordLessThanOrEqualTo(String value) {
            addCriterion("EncryptedClientPassword <=", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordLike(String value) {
            addCriterion("EncryptedClientPassword like", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordNotLike(String value) {
            addCriterion("EncryptedClientPassword not like", value, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordIn(List<String> values) {
            addCriterion("EncryptedClientPassword in", values, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordNotIn(List<String> values) {
            addCriterion("EncryptedClientPassword not in", values, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordBetween(String value1, String value2) {
            addCriterion("EncryptedClientPassword between", value1, value2, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPasswordNotBetween(String value1, String value2) {
            addCriterion("EncryptedClientPassword not between", value1, value2, "encryptedClientPassword");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2IsNull() {
            addCriterion("EncryptedClientPassword2 is null");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2IsNotNull() {
            addCriterion("EncryptedClientPassword2 is not null");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2EqualTo(String value) {
            addCriterion("EncryptedClientPassword2 =", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2NotEqualTo(String value) {
            addCriterion("EncryptedClientPassword2 <>", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2GreaterThan(String value) {
            addCriterion("EncryptedClientPassword2 >", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2GreaterThanOrEqualTo(String value) {
            addCriterion("EncryptedClientPassword2 >=", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2LessThan(String value) {
            addCriterion("EncryptedClientPassword2 <", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2LessThanOrEqualTo(String value) {
            addCriterion("EncryptedClientPassword2 <=", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2Like(String value) {
            addCriterion("EncryptedClientPassword2 like", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2NotLike(String value) {
            addCriterion("EncryptedClientPassword2 not like", value, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2In(List<String> values) {
            addCriterion("EncryptedClientPassword2 in", values, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2NotIn(List<String> values) {
            addCriterion("EncryptedClientPassword2 not in", values, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2Between(String value1, String value2) {
            addCriterion("EncryptedClientPassword2 between", value1, value2, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andEncryptedClientPassword2NotBetween(String value1, String value2) {
            addCriterion("EncryptedClientPassword2 not between", value1, value2, "encryptedClientPassword2");
            return (Criteria) this;
        }

        public Criteria andMinCollectorIsNull() {
            addCriterion("MinCollector is null");
            return (Criteria) this;
        }

        public Criteria andMinCollectorIsNotNull() {
            addCriterion("MinCollector is not null");
            return (Criteria) this;
        }

        public Criteria andMinCollectorEqualTo(BigDecimal value) {
            addCriterion("MinCollector =", value, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorNotEqualTo(BigDecimal value) {
            addCriterion("MinCollector <>", value, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorGreaterThan(BigDecimal value) {
            addCriterion("MinCollector >", value, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("MinCollector >=", value, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorLessThan(BigDecimal value) {
            addCriterion("MinCollector <", value, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorLessThanOrEqualTo(BigDecimal value) {
            addCriterion("MinCollector <=", value, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorIn(List<BigDecimal> values) {
            addCriterion("MinCollector in", values, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorNotIn(List<BigDecimal> values) {
            addCriterion("MinCollector not in", values, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MinCollector between", value1, value2, "minCollector");
            return (Criteria) this;
        }

        public Criteria andMinCollectorNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MinCollector not between", value1, value2, "minCollector");
            return (Criteria) this;
        }

        public Criteria andIssuePriceIsNull() {
            addCriterion("IssuePrice is null");
            return (Criteria) this;
        }

        public Criteria andIssuePriceIsNotNull() {
            addCriterion("IssuePrice is not null");
            return (Criteria) this;
        }

        public Criteria andIssuePriceEqualTo(BigDecimal value) {
            addCriterion("IssuePrice =", value, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceNotEqualTo(BigDecimal value) {
            addCriterion("IssuePrice <>", value, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceGreaterThan(BigDecimal value) {
            addCriterion("IssuePrice >", value, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("IssuePrice >=", value, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceLessThan(BigDecimal value) {
            addCriterion("IssuePrice <", value, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceLessThanOrEqualTo(BigDecimal value) {
            addCriterion("IssuePrice <=", value, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceIn(List<BigDecimal> values) {
            addCriterion("IssuePrice in", values, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceNotIn(List<BigDecimal> values) {
            addCriterion("IssuePrice not in", values, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IssuePrice between", value1, value2, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andIssuePriceNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("IssuePrice not between", value1, value2, "issuePrice");
            return (Criteria) this;
        }

        public Criteria andRPCHost2IsNull() {
            addCriterion("RPCHost2 is null");
            return (Criteria) this;
        }

        public Criteria andRPCHost2IsNotNull() {
            addCriterion("RPCHost2 is not null");
            return (Criteria) this;
        }

        public Criteria andRPCHost2EqualTo(String value) {
            addCriterion("RPCHost2 =", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2NotEqualTo(String value) {
            addCriterion("RPCHost2 <>", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2GreaterThan(String value) {
            addCriterion("RPCHost2 >", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2GreaterThanOrEqualTo(String value) {
            addCriterion("RPCHost2 >=", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2LessThan(String value) {
            addCriterion("RPCHost2 <", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2LessThanOrEqualTo(String value) {
            addCriterion("RPCHost2 <=", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2Like(String value) {
            addCriterion("RPCHost2 like", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2NotLike(String value) {
            addCriterion("RPCHost2 not like", value, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2In(List<String> values) {
            addCriterion("RPCHost2 in", values, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2NotIn(List<String> values) {
            addCriterion("RPCHost2 not in", values, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2Between(String value1, String value2) {
            addCriterion("RPCHost2 between", value1, value2, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andRPCHost2NotBetween(String value1, String value2) {
            addCriterion("RPCHost2 not between", value1, value2, "RPCHost2");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeIsNull() {
            addCriterion("TimingOpenTime is null");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeIsNotNull() {
            addCriterion("TimingOpenTime is not null");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeEqualTo(Date value) {
            addCriterion("TimingOpenTime =", value, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeNotEqualTo(Date value) {
            addCriterion("TimingOpenTime <>", value, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeGreaterThan(Date value) {
            addCriterion("TimingOpenTime >", value, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("TimingOpenTime >=", value, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeLessThan(Date value) {
            addCriterion("TimingOpenTime <", value, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeLessThanOrEqualTo(Date value) {
            addCriterion("TimingOpenTime <=", value, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeIn(List<Date> values) {
            addCriterion("TimingOpenTime in", values, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeNotIn(List<Date> values) {
            addCriterion("TimingOpenTime not in", values, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeBetween(Date value1, Date value2) {
            addCriterion("TimingOpenTime between", value1, value2, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenTimeNotBetween(Date value1, Date value2) {
            addCriterion("TimingOpenTime not between", value1, value2, "timingOpenTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeIsNull() {
            addCriterion("TimingOpenWithdrewTime is null");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeIsNotNull() {
            addCriterion("TimingOpenWithdrewTime is not null");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeEqualTo(Date value) {
            addCriterion("TimingOpenWithdrewTime =", value, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeNotEqualTo(Date value) {
            addCriterion("TimingOpenWithdrewTime <>", value, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeGreaterThan(Date value) {
            addCriterion("TimingOpenWithdrewTime >", value, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("TimingOpenWithdrewTime >=", value, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeLessThan(Date value) {
            addCriterion("TimingOpenWithdrewTime <", value, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeLessThanOrEqualTo(Date value) {
            addCriterion("TimingOpenWithdrewTime <=", value, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeIn(List<Date> values) {
            addCriterion("TimingOpenWithdrewTime in", values, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeNotIn(List<Date> values) {
            addCriterion("TimingOpenWithdrewTime not in", values, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeBetween(Date value1, Date value2) {
            addCriterion("TimingOpenWithdrewTime between", value1, value2, "timingOpenWithdrewTime");
            return (Criteria) this;
        }

        public Criteria andTimingOpenWithdrewTimeNotBetween(Date value1, Date value2) {
            addCriterion("TimingOpenWithdrewTime not between", value1, value2, "timingOpenWithdrewTime");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}